// 环境选择器管理类
class EnvironmentSelector {
    constructor() {
        this.currentProject = null;
        this.currentEnvironment = null;
        this.environmentManager = null;
        console.log('[环境选择器] 构造函数执行');
        this.init();
    }

    init() {
        console.log('[环境选择器] 初始化开始');
        this.bindEvents();
        // 等待环境管理器初始化完成
        this.waitForEnvironmentManager();
    }

    waitForEnvironmentManager() {
        console.log('[环境选择器] 等待环境管理器初始化...');
        const checkManager = () => {
            if (window.environmentManager) {
                console.log('[环境选择器] 环境管理器已可用');
                this.environmentManager = window.environmentManager;
                this.updateEnvironmentSelector();
            } else {
                console.log('[环境选择器] 环境管理器尚未可用，继续等待...');
                setTimeout(checkManager, 100);
            }
        };
        checkManager();
    }

    bindEvents() {
        // 监听环境选择变化
        const envSelect = document.getElementById('environment-select');
        envSelect.addEventListener('change', (e) => {
            this.onEnvironmentChange(e.target.value);
        });

        // 监听URL输入框变化
        this.bindUrlChangeEvents();

        // 监听标签页切换
        this.bindTabChangeEvents();
    }

    bindUrlChangeEvents() {
        const urlInput = document.getElementById('url-input');
        if (urlInput) {
            urlInput.addEventListener('input', () => {
                // 环境切换过程中不触发更新，防止循环
                if (!this._isEnvironmentSwitching) {
                    this.updateEnvironmentSelector();
                }
            });
            urlInput.addEventListener('blur', () => {
                // 环境切换过程中不触发更新，防止循环
                if (!this._isEnvironmentSwitching) {
                    this.updateEnvironmentSelector();
                }
            });
        }
    }

    bindTabChangeEvents() {
        // 监听标签页切换事件
        document.addEventListener('tabChanged', () => {
            this.updateEnvironmentSelector();
        });

        // 监听新标签页创建事件
        document.addEventListener('newTabCreated', () => {
            this.updateEnvironmentSelector();
        });
    }

    // 更新环境选择器显示状态
    updateEnvironmentSelector() {
        console.log('[环境选择器] 开始更新环境选择器');
        
        if (!this.environmentManager) {
            console.log('[环境选择器] 环境管理器不可用');
            return;
        }

        const urlInput = document.getElementById('url-input');
        if (!urlInput) {
            console.log('[环境选择器] URL输入框不存在');
            return;
        }

        const currentUrl = urlInput.value.trim();
        console.log('[环境选择器] 当前URL:', currentUrl);
        
        if (!currentUrl) {
            console.log('[环境选择器] URL为空，隐藏环境选择器');
            this.hideEnvironmentSelector();
            return;
        }

        // 提取上下文路径
        const contextPath = this.extractContextPath(currentUrl);
        console.log('[环境选择器] 提取的上下文路径:', contextPath);
        
        if (!contextPath) {
            console.log('[环境选择器] 上下文路径为空，隐藏环境选择器');
            this.hideEnvironmentSelector();
            return;
        }

        // 查找匹配的项目配置
        console.log('[环境选择器] 当前所有项目配置:', this.environmentManager.projectConfigs);
        const project = this.findProjectByContextPath(contextPath);
        console.log('[环境选择器] 找到的项目配置:', project);
        
        if (!project) {
            console.log('[环境选择器] 未找到匹配的项目配置，隐藏环境选择器');
            this.hideEnvironmentSelector();
            return;
        }

        // 显示环境选择器并更新选项
        console.log('[环境选择器] 显示环境选择器');
        this.showEnvironmentSelector(project, currentUrl);
    }

    // 从URL中提取上下文路径
    extractContextPath(url) {
        try {
            const urlObj = new URL(url);
            const pathParts = urlObj.pathname.split('/').filter(part => part);
            return pathParts.length > 0 ? pathParts[0] : null;
        } catch (e) {
            return null;
        }
    }

    // 根据上下文路径查找项目配置
    findProjectByContextPath(contextPath) {
        if (!this.environmentManager || !this.environmentManager.projectConfigs) {
            return null;
        }
        return this.environmentManager.projectConfigs.find(project => project.contextPath === contextPath);
    }

    // 显示环境选择器
    showEnvironmentSelector(project, currentUrl) {
        console.log('[环境选择器] 开始显示环境选择器，项目:', project.name, '，当前URL:', currentUrl);
        const selector = document.getElementById('environment-selector');
        const select = document.getElementById('environment-select');

        if (!selector || !select) {
            console.log('[环境选择器] 环境选择器DOM元素不存在');
            return;
        }

        this.currentProject = project;

        // 清空并重新填充选项
        select.innerHTML = '';

        console.log('[环境选择器] 项目环境列表:', project.environments);
        project.environments.forEach(env => {
            console.log('[环境选择器] 添加环境选项:', env.environment, '，基础URL:', env.baseUrl);
            const option = document.createElement('option');
            option.value = env.environment;
            option.textContent = this.getEnvironmentDisplayName(env.environment);
            option.dataset.baseUrl = env.baseUrl;
            select.appendChild(option);
        });

        // 自动匹配当前环境
        const currentBaseUrl = this.extractBaseUrl(currentUrl);
        console.log('[环境选择器] 提取的当前基础URL:', currentBaseUrl);
        
        // 详细日志环境匹配过程
        console.log('[环境选择器] 开始环境匹配，项目环境数量:', project.environments.length);
        const matchedEnv = project.environments.find(env => {
            console.log('[环境选择器] 比较环境URL - 环境:', env.environment, '，环境URL:', env.baseUrl, '，当前URL:', currentBaseUrl, '，是否匹配:', env.baseUrl === currentBaseUrl);
            return env.baseUrl === currentBaseUrl;
        });
        
        if (matchedEnv) {
            console.log('[环境选择器] 找到匹配的环境:', matchedEnv.environment);
            select.value = matchedEnv.environment;
            this.currentEnvironment = matchedEnv.environment;
            // 手动触发change事件，确保环境切换生效
            select.dispatchEvent(new Event('change'));
        } else {
            console.log('[环境选择器] 未找到匹配的环境');
            select.value = '';
            this.currentEnvironment = null;
        }

        // 显示选择器
        selector.style.display = 'inline-flex';
        console.log('[环境选择器] 环境选择器已显示，当前选中值:', select.value);
    }

    // 隐藏环境选择器
    hideEnvironmentSelector() {
        const selector = document.getElementById('environment-selector');
        if (selector) {
            selector.style.display = 'none';
        }
        this.currentProject = null;
        this.currentEnvironment = null;
    }

    // 从URL中提取基础地址
    extractBaseUrl(url) {
        try {
            const urlObj = new URL(url);
            return `${urlObj.protocol}//${urlObj.host}`;
        } catch (error) {
            return '';
        }
    }

    // 获取环境显示名称
    getEnvironmentDisplayName(envName) {
        if (!this.environmentManager || !this.environmentManager.environmentTypes) {
            return envName;
        }

        const envType = this.environmentManager.environmentTypes.find(
            type => type.name === envName
        );
        return envType ? envType.displayName : envName;
    }

    // 处理环境切换
    onEnvironmentChange(selectedEnv) {
        // 防止重复调用
        if (this._isEnvironmentSwitching) {
            return;
        }

        if (!selectedEnv || !this.currentProject) {
            return;
        }

        const urlInput = document.getElementById('url-input');
        if (!urlInput) {
            return;
        }

        const currentUrl = urlInput.value.trim();
        if (!currentUrl) {
            return;
        }

        // 找到选中环境的配置
        const envConfig = this.currentProject.environments.find(
            env => env.environment === selectedEnv
        );

        if (!envConfig) {
            return;
        }

        // 标记正在进行环境切换，防止循环触发
        this._isEnvironmentSwitching = true;

        try {
            // 替换URL中的基础地址
            const newUrl = this.replaceBaseUrl(currentUrl, envConfig.baseUrl);
            if (newUrl !== currentUrl) {
                urlInput.value = newUrl;
                this.currentEnvironment = selectedEnv;
            }
        } finally {
            // 等待URL更新完成后，再重置标记并加载标签页数据
            setTimeout(() => {
                // 环境切换完成，重置标记
                this._isEnvironmentSwitching = false;
                
                // 重新加载标签页数据以显示当前环境的专用参数
                if (window.app && window.app.currentTab && window.app.tabs) {
                    const currentTab = window.app.tabs.get(window.app.currentTab);
                    if (currentTab) {
                        // 保存当前环境的URL到标签页数据中
                        currentTab.url = urlInput.value;
                        
                        // 确保environments对象存在
                        if (!currentTab.environments) {
                            currentTab.environments = {};
                        }
                        
                        // 保存当前环境参数到environments对象
                        if (this.currentEnvironment) {
                            // 获取当前UI上的参数
                            const currentParams = app.getCurrentTabDataParams();
                            // 保存到对应的环境下
                            currentTab.environments[this.currentEnvironment] = currentParams;
                        }
                        
                        // 加载目标环境的参数（如果有）
                        if (selectedEnv && currentTab.environments[selectedEnv]) {
                            const envParams = currentTab.environments[selectedEnv];
                            // 设置UI上的参数
                            app.setTabDataParams(envParams);
                        } else {
                            // 如果是新环境，使用默认参数
                            window.app.loadTabData(currentTab);
                        }
                    }
                }
            }, 200);
        }
    }

    // 替换URL中的基础地址
    replaceBaseUrl(originalUrl, newBaseUrl) {
        try {
            const urlObj = new URL(originalUrl);
            const newUrlObj = new URL(newBaseUrl);
            
            // 保持原URL的路径、查询参数和片段
            return `${newUrlObj.protocol}//${newUrlObj.host}${urlObj.pathname}${urlObj.search}${urlObj.hash}`;
        } catch (error) {
            return originalUrl;
        }
    }

    // 获取当前选中的环境
    getCurrentEnvironment() {
        return this.currentEnvironment;
    }

    // 获取当前项目配置
    getCurrentProject() {
        return this.currentProject;
    }
}

// 全局环境选择器实例
let environmentSelector;

// 初始化环境选择器
document.addEventListener('DOMContentLoaded', () => {
    // 延迟初始化，确保环境管理器先初始化完成
    setTimeout(() => {
        environmentSelector = new EnvironmentSelector();
        // 导出给其他模块使用
        window.environmentSelector = environmentSelector;
    }, 1500); // 延迟1.5秒，确保环境管理器初始化完成
});